00000128: This is the initial jump over the Borland runtime header data (the ASCII string "Borland..." at 0x114) to the actual program entry point at 0x181.
0000015A: This is not a meaningful instruction — it's part of the ASCII string "multiply" embedded in the binary's data area, not executable code.
00000208: This is a delay loop subroutine — the `loop 0x206` at 0x206 spins CX times (loaded from `[0x12]`), and the `pop cx` at 0x208 restores the outer loop counter, implementing a nested software timing delay used for serial pacing.
00000223: Boot-prompt cursor setup for a custom video function.  But that's not very specific.  Alternatively, note the instruction after the custom INT 10h: mov dx, [0x4]   -> then sets the cursor again. So [0x4] is a cursor position. The custom function might have use
000002A4: This is a BIOS video scroll-up function call (INT 10h, AH=06h) used to clear or scroll a window on the text-mode screen, part of the terminal display management.
000002F6: This stores the video mode number (from INT 10h AH=0Fh) into `[0x6]` — it's part of the video-mode detection/setup routine that saves the current text mode for later cursor and screen operations.
00000318: This is part of the video mode detection/setup routine — the `jz 0x321` at 0x318 checks if the current video mode (returned by INT 10h AH=0Fh) matches the saved mode at `[0x6]`, and if not, re-initializes the video mode.
000004A9: This is a clipping check in a BIOS INT 10h video cursor/window function — `or dx,dx` tests if the Y coordinate is negative (invalid), and if so jumps to skip the INT 10h call.
0000084F: This is a keyboard input routine that checks for a pending keypress via INT 16h AH=1 (BIOS keyboard status), returning 0xFF if a key is available or 0x00 if not, and the marked instruction loads the flag byte at [0x192] which tracks whether a key was previousl
00000963: This increments SI to skip over a word in a table (the second `inc si` after checking `[si]` for zero) — it's part of a subroutine that searches through a list of file handles or buffer pointers at `[0x17a]` for an empty slot, used by DOS file-open operations.
0000097C: This pushes SI to save the pointer before entering a loop that searches for a matching value (BX) in a word table at `[0x17a]` — it's part of a file-handle deallocation or buffer-release routine that zeroes out entries in the handle table.
00000A51: This is the cleanup epilogue of a Borland runtime wrapper function that restores registers (di, dx, cx, bx) after calling a function pointer at [0x13a], used as a gate for INT 14h or other system calls.
00000D29: This tests if AL is zero (OR AL,AL) to check for end-of-string while copying a filename path, immediately before calling DOS function 0x3D00 (open file) to open PARMS.DAT or another configuration file.
00000D72: Copying a constant string to a buffer for display.  Sample 4 (0x00000DDF): Instructions: ... >>>>  00000DDF  3C09              cmp al,0x9 00000DE1  7404              jz 0xde7 ...  Context: The function is: cmp al,0x20 -> jz 0xdd0 -> then cmp al,0x9 -> jz 0xde7
00000DAB: This is a Borland runtime string-copy stub — the `pop ds` at 0xDAB switches DS to CS (the code segment) to copy a string from the code segment onto the stack, implementing a Pascal-style string duplication.
00000DDF: Skipping tab characters during string length trim.  Sample 5 (0x00000E03): Instructions: ... >>>>  00000E03  51                push cx 00000E04  BBB600            mov bx,0xb6 00000E07  E8F202            call 0x10fc  Context: The function does: ... push bx, the
00000E03: Preparing for a file read by setting up a buffer address.  Sample 6 (0x00000E50): Instructions: ... >>>>  00000E50  91                xchg ax,cx 00000E51  BBB600            mov bx,0xb6 00000E54  8A07              mov al,[bx] 00000E56  43                inc bx
00000E29: This sets BX=0xB6 (182 decimal) as a divisor or comparison value before calling a subroutine at 0x1F22, likely a division or formatting routine used in converting numeric parameters (e.g., baud rate) from PARMS.DAT.
00000E50: Swapping AX and CX to use CX as a loop counter for string copy.  Sample 7 (0x000013A3): Instructions: ... >>>>  000013A3  47                inc di 000013A4  4A                dec dx 000013A5  75F1              jnz 0x1398  Context: The function does: ... push c
00000EE2: This sets DI to 0xB6 as the destination for a string copy — used in a routine that copies a command-line argument or parameter string into a fixed buffer at offset 0xB6.
00000F4F: This sets SI = DI to prepare for a string copy operation, part of a Borland runtime function that copies a data structure from one segment to another using REP MOVSB.
00000FDB: This calls the Borland keyboard-input subroutine at 0x836 to read a character, checking for a keypress during the executive-loading process (the result is tested for zero to see if a key was pressed).
00001058: This CLI instruction disables interrupts — it's part of a critical section protecting an I/O operation (likely serial port access via INT 14h) from being interrupted, with the string "\r\nI/O" at 0x1060 being an error message for I/O failures.
00001060: This is inline data (the string "\r\nI/O" at 0x1060-0x1065) embedded in the code, used as an error message prefix for I/O error reporting; the preceding call at 0x105d prints the string via the Borland output routine at 0xa62.
00001111: This is part of a signed integer-to-ASCII conversion routine — `call 0x1123` with `dx=0x3e8` (1000) divides the number by 1000 to extract the thousands digit, used for formatting numeric values like baud rates or coordinates.
000011D2: This is another Borland runtime string-copy stub — the `push cs` at 0x11D2 followed by `pop ds` sets DS to the code segment to copy a counted string (length byte at `[cs:si]`) from the code segment onto the stack.
00001232: This is a sign-flag check (jns 0x1245) in a Borland string-manipulation routine, determining whether the difference between two string pointers is non-negative to decide whether to copy data forward or backward during an insert/delete operation.
000012C4: This exchanges CX and DX (xchg cx,dx) to ensure the shorter string length is in CX for the subsequent `repe cmpsb` string comparison, implementing a minimum-length comparison in a Borland string-sorting or comparison routine.
000012D5: This is a string comparison routine — the `cmp ah,al` at 0x12D5 compares the high and low bytes of AX after a `repe cmpsb` loop, implementing a case-insensitive or length-aware comparison fallback when the strings match up to the minimum length.
000013A3: Searching for a token in PARMS.DAT.  Sample 8 (0x0000161D): Instructions: ... >>>>  0000161D  7505              jnz 0x1624 0000161F  3BD1              cmp dx,cx 00001621  7501              jnz 0x1624 00001623  48                dec ax 00001624  0BC0
00001561: This is a string comparison subroutine — the `mov ds,dx` at 0x1561 restores the original data segment from DX after a `repe cmpsw` word comparison, as part of a Borland string-comparison function that saves/restores DS.
00001574: This is a call to a string comparison helper — the `call 0x15f4` at 0x1574 invokes a subroutine that sets up for a `repe cmpsw` comparison, part of a Borland string-comparison function that compares two strings word-by-word.
00001587: This is the tail end of a string comparison subroutine (likely `strcmp` or `memcmp`), where the `jmp short 0x158b` at 0x1587 skips the `xor ax,ax` (set result to 0/false) to instead fall through with AX=1 (true/match), before restoring DS from DX and returning
000015CC: This calls subroutine 0x15DD to test a bit in a bitmapped array on the stack — it's part of a Borland runtime heap-management routine that checks whether a memory block is free (bit test in a stack-based allocation bitmap).
00001784: This is a bit-rotate instruction within a CRC or checksum calculation loop (part of the executive file loading integrity check), rotating DX left through carry as part of a polynomial division.
000019D4: This is a stack-frame manipulation routine that toggles the high bit (bit 7) of a byte on the stack, likely used to set/clear the high-bit marker for PDP-11 serial communication protocol.
00001ACA: This instruction clears the high bit (bit 7) of `bh`, stripping the PDP-11's echo marker (bit 7 set) from an incoming byte, preparing it for display or processing in the terminal interface.
00001AF9: This increments `ax` as part of a rounding operation in a fixed-point arithmetic routine, likely used for coordinate calculations in pattern data processing.
00001B88: This pops a return address into [0x186] (a function pointer storage), then loads constants 0x2181, 0xDAA2, 0x490F into registers — these are likely seed values for a CRC-32 or checksum algorithm used during executive file verification.
00001BC1: This calls subroutine 0x193E, which is part of the executive file loading protocol — likely a byte-sending routine that transmits a character from the .TAP file to the PDP-11 via INT 14h serial output.
00001BF9: This pops flags from the stack (popf) to restore the carry flag state, then conditionally toggles bit 7 of DH (XOR with 0x80) — part of the serial protocol's high-bit handling for PDP-11 echo responses.
00001C8F: This loads `di` with address 0x3172, which is a known data buffer or string constant, preparing for a call to the CRC or checksum routine at 0x162f during executive file processing.
00001CA6: Call to subroutine at 0x1722, which is the INT 14h serial send wrapper, to transmit a byte from the executive file buffer at 0x17f7 during the PDP-11 executive loading process.
00001CB9: Jump to 0x1992, which is the main terminal-mode loop or command dispatcher, after clearing registers to indicate a successful executive load or error condition.
00001D2F: This is part of a CRC or checksum calculation routine, where `mov si,0xf333` loads a constant pointer for a lookup table or polynomial used in the pattern file integrity check.
00001D42: Sets `si` to `bx` (a pointer to a data buffer) and `di` to `dx` (a pointer to a destination), then calls 0x179c, which is the INT 14h serial receive wrapper, to read a byte from the PDP-11 controller.
00001DF0: This stores AX (a computed value) into [0x21A], part of a loop that processes a table of three-word entries (CX, SI, DI) at [CS:DI] — likely parsing the executive file's header or pattern data structure.
00001E2C: The `pop bx` at 0x1E2C is restoring BX from the stack as part of a multi-register restore sequence (AX, BX, DX) before calling subroutine 0x179c, which is likely a file-read or serial-send routine that uses BX as a handle or buffer pointer.
00001EA8: This `dec cx` instruction is in a region of padding bytes (0xCC int3 instructions) and ASCII data, so its purpose is UNKNOWN.
00001EB2: This instruction (`dec sp`) is likely data or padding, not executable code; it appears in a region of `int3` padding bytes (0xCC) and ASCII data (`AA`), so its purpose is UNKNOWN.
00001EEF: This `push di` saves the DI register before a jump to 0x1F02, which loads saved register values from memory locations [0x21A], [0x21C], and [0x21E] and calls 0x1722, a subroutine that likely handles serial communication or terminal I/O.
00001F45: Sets `dl` to the value in `al` (a computed column position), then calls 0x1fe6, which is the INT 10h cursor-positioning subroutine, to place the cursor at the correct column for text output on the screen.
00001FF9: This `inc si` increments the SI pointer as part of a loop (0x1FF5-0x1FFF) that fills memory from 0x226 to 0x232 with the value 0x3030 (ASCII "00"), likely initializing a buffer for numeric display or configuration.
0000202D: This is a call to a subroutine at 0x2225 that performs a bit-shift operation (shr/rcr) on a 32-bit value in DX:BX:AX, likely part of a serial data encoding or CRC calculation routine used in the PDP-11 communication protocol.
000020F7: This `mov al,cl` moves the character in CL to AL, then calls 0x18BB (a character conversion routine like uppercase), preparing for a string comparison via call to 0x162F, part of the PARMS.DAT value parsing logic.
000020FF: The `pop si` at 0x20FF restores SI from the stack after a call to 0x18BB (which converts a character in AL to uppercase or similar), preparing to call 0x162F (a string comparison or search routine) with SI pointing to one of the operands.
00002120: Increments `si` to advance through a string buffer, then jumps back to 0x20d8, continuing a loop that parses a filename or path string (looking for '.' or 'E' characters).
00002129: This loads `cl` from memory address `[0x225]`, which is a stored character or flag byte used in filename parsing (checking for 'E' extension or format specifier).
0000219F: This pushes `bx` onto the stack to save it before modifying `bx` in a lookup-table calculation for a jump table or dispatch routine (based on the `lea di,[bx+0x21e9]` that follows).
00002254: This `ret` instruction returns from a subroutine that performs arithmetic operations (adc, rcr) and ends with `and dh,0x7f` and `add al,0x3`, likely a serial protocol handler that strips the high bit from PDP-11 responses.
00002274: This is a loop that right-shifts a 32-bit value (BX:CX) by AL bits, used in a bit-manipulation subroutine for serial data processing or checksum computation in the PDP-11 link layer.
00002331: This conditional jump checks if byte [0x180] is non-zero, branching to address 0x239d; it is part of a DOS file-handling or device-control routine (likely testing for an error flag or EOF condition after a call to 0x23ed).
00002627: This calls subroutine 0x2547, which is the keyboard input/line editor routine that handles character entry, backspace, and buffer management for operator text input.
00002725: Calls subroutine at 0x26d2, which is a string comparison or filename-matching routine, to compare a directory entry name against a search pattern during file-list processing.
000027DF: This is a simple return instruction (RET) at the end of a dispatch table for file operations; it is the default case when CL does not match values 1, 3, or 4, falling through to call the indirect address stored at [0x142] (likely a generic file-read or error h
00002802: This stores `dx` (the current buffer offset) into `[es:di+0x8]` as part of a file-write operation, updating the buffer position pointer before calling the DOS write wrapper at 0x93a to save pattern data to disk.
00002809: This is a DOS file-write wrapper (INT 21h AH=0x40) that writes data from a buffer to a file handle, where `call 0x93a` invokes the DOS write function to save pattern data to disk.
00002974: The `pop word [0x186]` at 0x2974 pops a return address into memory location 0x186 (a temporary storage for a jump target), then restores ES from the stack and pushes the saved address back, setting up for a DOS INT 21h AH=0x40 (write to file) call at 0x93A, pa
00002979: This instruction pushes the return address stored at [0x186] back onto the stack, setting up for a DOS INT 21h AH=0x40 (write to file) call, part of the file-output wrapper used for saving pattern data or logging.
0000298A: This pops a return address into memory location 0x186, part of a common entry/exit sequence for DOS INT 21h AH=0x40 (write to file) calls, used in the file-output wrapper for saving pattern data or printer output.
000029C1: This `mov word [0x238],0xf040` sets a word at [0x238] to 0xF040, which is later used as a high byte (AH) for a DOS write call (INT 21h AH=0x40), preparing for file output operations.
000029D3: The `les di,[0x232]` at 0x29D3 loads ES:DI from the far pointer stored at [0x232] (a file control block or buffer pointer), preparing to read a file handle (BX) and byte count (CX) for a DOS write call (INT 21h AH=0x40) at 0x93A, part of a file-save or data-tr
00002A19: This is part of a file-positioning routine (DOS INT 21h AH=0x42 lseek) that restores the high word of the 32-bit file offset from the stack into BX, then compares the resulting file position against a previously saved length to detect a read error or short rea
00002A47: This pops ES from the stack and pushes BX, setting up for a DOS INT 21h AH=0x42 (lseek) call with AL=0x01 (seek from current position), used in file-position management during pattern file I/O.
00002BA5: This is a DOS file-rename wrapper (INT 21h AH=0x56) that renames a file, where `push es` saves the extra segment before swapping segments for the DOS call to rename a pattern or parameter file.
00002BFC: This `jmp short 0x2c00` is a conditional branch that selects between BH=0x39 and BH=0x3A (ASCII "9" and ":"), part of a routine that sets up a DOS function call (AH=0x3B, set current directory) at 0x2BF1, used for directory navigation in file operations.
00002D3A: The `call 0xf70` at 0x2D3A is the Borland runtime cleanup stub that follows an INT 21h call (at 0x2D38), restoring registers and cleaning up after the DOS service (AH=0x40 write or similar file operation), part of the standard Borland calling convention for DO
00002D6A: This is a circular buffer index wrap-check in a hardware interrupt handler (likely serial or timer), comparing BX against 0x370F to reset the buffer pointer when it reaches the buffer end, part of the PDP-11 communication layer's ring buffer management.
00002D84: This increments a word counter at [0x3ABF] and updates a maximum value at [0x3AC1], part of a hardware interrupt handler (likely timer or serial) that tracks buffer usage or timing statistics in the PDP-11 communication layer.
00002D9B: This is the epilogue of a hardware interrupt handler (likely the timer or serial interrupt) that restores all registers and returns via `iret`, part of the PDP-11 communication timing/buffer tracking layer.
00002DD0: Stores zero into memory location 0x3ac1, which is part of the PARMS.DAT configuration variable area, initializing a parameter (likely the baud rate or delay value) to zero during startup.
00002E10: This loads a shift count from `[0x3abc]` to set a bit mask for manipulating the interrupt controller (port 0x21), part of the interrupt masking/unmasking logic for serial or timer interrupts.
00002E43: This stores AL (zero) into memory location [0x3AB7], clearing a flag or counter variable as part of a hardware initialization or interrupt reset routine for the serial/UART interface.
00002F45: This is a loop counter increment in a delay routine, incrementing a local variable from 0 to 8 to create a timed delay loop, likely used in the serial communication timing.
00002F93: This calls subroutine `0x14d9` with a character pushed on the stack, part of a routine that builds a file attribute/status byte by checking for specific characters (here 'E' and 'e') to determine if a file is an executive file.
00002FAA: This loads a file attribute byte from the stack and ORs it with 0x18 (bits for volume label and directory), marking the file as an executive file type during the file-list scanning routine.
00002FB9: This zeros `ah` and pushes a character for a call to `0x14d9`, part of the same file-type detection routine checking for 'O' and 'o' characters to identify pattern files.
00002FBF: This loads the ASCII value 0x4F ('O') into AX as a parameter for the character comparison subroutine at 0x14eb, part of the file-type detection logic that checks for 'O' or 'o' to identify pattern files.
0000306C: The `mov ax,0x2f8` at 0x306C loads AX with the I/O port address 0x2F8 (COM2/COM3 serial port base address), storing it at [0x3ABA] as part of the UART address configuration for the serial communication setup (baud rate, parity, etc.) during PARMS.DAT parsing.
000030B4: This loads a byte parameter from the stack (the character to check) for a call to `0x2eea`, part of a file-type classification routine that examines filename characters.
000030E8: The `mov al,[bp+0xe]` at 0x30E8 loads AL from the stack frame parameter at offset 0x0E (a boolean or status flag), zero-extending it to AX and testing it before returning, part of a subroutine that initializes serial port parameters and returns a success/failu
000030F6: This MOV BP, SP sets up the stack frame for a new subroutine (function prologue), indicating the start of a function that will use BP-relative addressing for local variables and parameters, typical of Borland Pascal or C compiled code.
00003149: This is a counter reset for a progress indicator during executive loading — `mov ax,0x0` resets the counter at `[0x3ac5]` when it exceeds `0x370f`, which is the wrap point for the "Loading..." progress display.
00003182: This MOV [0x397], AX stores the value 0x80 into a global variable at address 0x397, which is likely a flag or threshold value used in a subsequent comparison or display routine (possibly related to screen width or buffer size).
0000318B: This stores AX (zero) into memory location [0x397], clearing a global variable that likely controls a screen-width or buffer-size threshold used in the text-display or pattern-formatting routine.
0000326D: This is a serial-port status check (reading the UART line status register at [0x3ABA]+5), testing bit 5 (0x20) for Transmitter Holding Register Empty, then setting AX=1 if empty or AX=0 if not, used in the INT 14h transmit-ready polling loop.
000032AA: This sets up the stack frame (BP = SP) for a subroutine that handles serial port output (OUT DX, AL), likely part of the UART initialization or byte-transmission wrapper for the PDP-11 communication.
00003320: This pushes `ss` and `di` (pointing to a local buffer) for a call to `0x30f5`, part of a delay loop routine that waits for a specific time period during the boot-prompt sequence.
0000332C: This is an unconditional jump to the subroutine epilogue at `0x332f`, reached when the delay loop condition is satisfied, part of the boot-prompt timing routine.
000033ED: This is NOT executable code — it's the embedded ASCII string "V2 off and move key to HALT position." (the boot-prompt message displayed to the operator before loading the executive), being decoded as data by the disassembler.
0000341F: This is the "Turn power to V2 off and move key to HALT position." boot-prompt string being printed — the `call 0x28d9` at 0x341F invokes the string-printing subroutine that outputs the embedded text starting at 0x3422 ("Now turn power to V2 back on...").
00003500: This loads a byte from `[0x3acc]` (a character buffer) for comparison against `0x1f` (space character), part of a routine that validates or processes a character from the PARMS.DAT parsing or keyboard input.
0000361D: This pushes argument `0x1` for a call to the Borland runtime delay/sleep function at `0xd8b` — part of the boot-prompt sequence that displays "Turn power to V2 off..." messages with timing delays.
00003705: This calls the string-printing subroutine at `0x26e0` to display the boot prompt "Turn power to V2 off and move key to HALT position." (the string at `0x32dc` is referenced via `di=0x14a` as an offset from a base pointer).
00003778: This calls the keyboard input subroutine at 0x26E0 to read a keypress, checking if it's ESC (0x1B) to abort the executive loading process.
000037EA: This calls subroutine 0x11c6 (a string output routine) to display the "Loading..." progress message during executive file transfer, after the pointer to the string at 0x3ae7 has been set up.
00003803: This MOV AX, 0x0A pushes the value 10 (line feed character) as a parameter to the call at 0x32a9, which is the boot-prompt printer subroutine (the "Turn power to V2 off..." sequence), outputting a newline after the carriage return (0x0D) pushed just before.
00003825: This calls the INT 14h serial initialization wrapper at `0xd8b` with `ax=0x3` (AH=0, AL=3 for 9600 baud, 8 bits, 1 stop, no parity) to configure the serial port before loading the executive.
00003886: This loads `di` with `0x3b1a`, which is the address of the string "Set Baud Rate - Example: 300,1200,9600" — preparing to display the first PARMS.DAT configuration prompt.
00003965: This is inline string data for "checking controller..." — the instruction at `0x3965` is actually the start of the ASCII string "checking controller..." that appears in the disassembly as immediate operands.
000039C7: This calls the routine at `0x2835` which is the "Loading exec..." string display function — it prints the string starting at address `0x3ae7` (which contains "Loading exec...") to the screen.
00003AAD: This calls subroutine 0x30f5 (a string input routine) to read the user's response for the "Set Baud Rate" prompt during PARMS.DAT configuration, checking if a valid value was entered.
00003B0D: This sets AX=1 to indicate a "true" or "valid" result after a PARMS.DAT parsing/comparison operation, storing it at [bp-0x6] as a success flag.
00003C39: This calls subroutine 0x24e9 (a cursor positioning routine) to set the cursor position for displaying the "Set parity" prompt, after pushing row=5 and column=7 as parameters.
00003C3C: This calls the string-printing subroutine at `0x28d9` to display the "Set parity - Example:" prompt (the string starting at `0x3c3f` with "Set parity").
00003EF9: This CALL 0x24E9 invokes a subroutine that likely handles a DOS file operation (such as opening, reading, or writing a file), as it is preceded by a call to 0x2882 (which sets up a file path or buffer) and followed by calls to 0x1003 and 0xD8B (Borland runtime
00003F26: This conditional jump (jnz) checks the result of the `call 0x3acd` (baud rate validation subroutine) — if non-zero (valid), it stores the parsed baud rate value; if zero (invalid), it displays error code 0x43 ('C').
00003F52: This calls the INT 14h serial send wrapper at `0xd8b` with `ax=0x5` (AH=1, AL=0x41 = 'A') to transmit the character 'A' to the PDP-11 controller.
00003F6C: This instruction (0x00B1) is actually data being interpreted as code; the real code continues at 0x3F6E, where the value 0x10 is loaded into CL for the hex string-to-number conversion subroutine at 0x272f, parsing the UART address from PARMS.DAT.
00003F7B: This is part of a string-to-number conversion routine (likely parsing a numeric value from PARMS.DAT), calling a subroutine at 0x272f that converts a hex/ASCII string to a binary value, with CL=0x10 indicating a 16-bit conversion.
00003F87: This is an unconditional jump to address 0x3F93, skipping the code that stores the parsed UART address value, executed when the string-to-number conversion at 0x272f fails (returns non-zero), indicating an invalid address format in PARMS.DAT.
00003FE4: This conditional jump (`jnz 0x3fe9`) checks the result of a call at `0x3acd` — if non-zero, it stores a value at `[0x3ad0]` (the controller address string pointer) during PARMS.DAT parsing.
00003FF2: This loads `ax` with `0x43` ('C') to be pushed as a parameter, part of a PARMS.DAT parsing routine that displays an error message when the controller address string is invalid.
0000409C: This is a logical right-shift of AX by 1 (shr ax,1), used in a bit-manipulation or division-by-two operation within a pattern-data processing routine (likely converting between byte counts or addressing modes).
000040A4: This sets CL=0x10 (16 decimal) as a shift count or loop counter before calling subroutine 0x272f, which is likely a bit-field extraction or binary-to-hex conversion routine (used in pattern file parsing or display formatting).
000040F2: This pushes DI onto the stack before calling 0x11c6, which is a Borland runtime string-copy or concatenation routine (part of building a file path or display string from components).
000041C9: This pushes AX=0x41 ('A') onto the stack before calling 0xD8B (a DOS print-string or character-output routine), part of constructing and displaying a menu option or prompt string in the operator interface.
00004335: This is inline string data (`": "` followed by the start of "A:\Parms.dat") — part of the PARMS.DAT file path display or error message during configuration file reading.
0000433D: This is a far jump instruction (`jmp 0x83e8:0x5716`) that appears to be data misinterpreted as code — likely part of a string constant or embedded data, not actual executable code.
000043D0: This loads AX with 0x5901 (DOS function 0x59 = Get Extended Error, with AL=01 for extended error class) to check for a specific error condition after a file operation, storing the result at [0x385] to indicate success/failure.
000043E5: This stores AL=0 at [0x385] to indicate that no DOS extended error occurred after a file operation, clearing the error flag before proceeding.
00004530: This loads AL from memory address [0x387], which holds a flag indicating whether the PARMS.DAT file was successfully opened/read — checking if the configuration file exists.
000045DD: This loads `ax` with `0x4e` (ASCII 'N') and pushes it as a parameter — preparing to write the character 'N' to a file or buffer during pattern file import/export operations.
000046D0: Call to subroutine 0x24cc, which is likely a string display or terminal output function, used here to print one of the PARMS.DAT configuration prompts (such as "Set Baud Rate" or "Set word bits") during the interactive setup phase.
000046EA: Loading DI with address 0x3af8, which corresponds to the string "Set stop bits" (based on the known string offsets), preparing to display this PARMS.DAT configuration prompt to the operator.
00004A64: Push of DS register onto stack, followed by inline string data "for example: 300, 1200, 9600" (visible in the disassembly as ASCII text), preparing to display this example string as part of the baud rate configuration prompt.
00004B22: The call at 0x4B22 to 0x28D9 is invoked after detecting F4 (0xF4) keypress, initiating the "load pattern tape" function, with the embedded string "Warning!! You are about to erase a file" nearby indicating a confirmation prompt before pattern loading.
00004B60: This is part of the string "Press <ESC> to halt loading of exec." — the `jc` instruction at 0x4B60 is actually data bytes (0x72 0x6E = "rn") embedded within the text message.
00004B8E: This is part of the string "Subject channel name" — the `and [bp+di+0x68],ah` at 0x4B8E is actually data bytes (0x20 0x63 0x68 = " ch") within the text message displayed during pattern file operations.
00004D4A: This calls the DOS print-string function (`INT 21h, AH=09h`) via the Borland runtime at `0x1003` — it prints the "No listings in directory" message that follows at address `0x4d53`.
00004D95: This conditional jump checks if the file at DS:0x334 (the "LIST.DAT" directory listing) was successfully opened — if non-zero (success), it continues processing; if zero (failure), it jumps to skip the file listing display.
00004EFD: Pushes a far pointer (segment:offset) onto the stack as a parameter for a call to 0x1609, which is likely a string comparison or search routine used during PARMS.DAT parsing to match a parameter value.
00004F3D: Stores the value 1 into memory location [0x38d], which appears to be a flag or counter variable used to track the result of a PARMS.DAT parsing operation (e.g., indicating a successful match or the current line number being processed).
00005105: This is the function prologue (`push bp` / `mov bp,sp`) for a subroutine that handles file-list display or directory scanning — it sets up the stack frame for a function that processes LIST.DAT or pattern file operations.
000052B7: Call to subroutine 0x1609, which is likely a string comparison or pattern-matching function used in PARMS.DAT parsing to check if a parsed token matches an expected parameter value (such as "TRINITY" for the password).
000052C3: This is a conditional jump that skips a block of code when a comparison result is zero, likely part of a PARMS.DAT parsing routine that checks for a specific parameter value before proceeding to the next parsing step.
000052D2: Pushes the value 0xF (15) onto the stack as a parameter for a call to 0xD8B, which is likely a memory allocation or array indexing routine, with the value representing a buffer size or offset used during PARMS.DAT parsing.
000053EA: This decrements AX (which was loaded from [0x38b], a counter or index) before pushing it as a parameter, part of a loop that processes items in a list (likely pattern files or directory entries) where the count needs to be adjusted for zero-based indexing.
000053F9: This pushes AX (a far pointer segment) onto the stack as a parameter for a call to 0x1609 (a string comparison or memory comparison routine), part of a filename or path matching operation in the pattern file management code.
0000541B: This pushes the value 0xF (15) onto the stack as a parameter for a subsequent call to 0xD8B, which is likely a string formatting or display routine that uses this value as a field width or buffer size parameter.
00005423: This is a signed divide instruction (IDIV) that divides the value at [0x38B] by 2, likely calculating a half-width or centering offset for a text display routine, possibly for the file-list display or menu formatting.
00005441: This pushes the ES segment register onto the stack as a parameter for a call to 0x11AD, which is likely a string copy or concatenation routine that expects a far pointer (segment:offset) to a destination buffer.
000055B9: Calls subroutine 0x274, which is likely a string length calculation or null-terminator search routine used during pattern file path parsing or directory listing operations.
000055D9: Loads a far pointer from a double-indirect reference ([es:di]) to access a structure field at offset 0x24, preparing parameters for a call to 0x1609 (string comparison) as part of a PARMS.DAT parameter validation routine.
00005833: Pushes the value 1 onto the stack as a parameter for a call to 0xD8B, which is likely a memory allocation or array indexing routine, with the value representing an index or flag used in the pattern file loading or display routine.
000058AC: This pushes ES and DI onto the stack as a far pointer parameter for a subsequent call, likely passing a destination buffer address to a string manipulation or display routine in the file-list or pattern-loading code.
000058D5: This loads ES:DI with a far pointer from [BP+0x8], which is a parameter passed to the current function, likely a buffer address for storing parsed configuration data or file path strings.
000058DA: This calls subroutine 0x55C5, which is likely a string comparison or parsing routine that checks the character just read against expected values (CR, ESC) in the terminal input handling or pattern-loading code.
00005975: This is a standard far-pointer return from a subroutine that takes 3 far-pointer arguments (6 bytes of parameters), used throughout the Borland runtime for returning 32-bit pointers.
000059F0: This is an unconditional jump that skips over a block of code, likely part of a conditional branch in the pattern-loading or file-selection routine where one path handles a successful operation and the other handles an error or alternative case.
00005A35: Loads the effective address of a stack buffer at [bp-0x52] and pushes it as a far pointer parameter for a call to 0x11AD, which is a string copy routine used to copy a pattern file name or path during file list display.
00005A7F: The call to 0x11AD at 0x5A7F is a string copy or concatenation routine, copying data from a structure at [bp-0x6] offset 0x15 (21 bytes into the structure) to build a file path or command string.
00005A9E: This loads ES:DI from [BP+0x6] (a far pointer parameter) to pass to a string concatenation or copy routine at 0x11c6, part of building a full pathname from a directory and filename component.
00005ACE: This stores AL (which was just set to 0x00) into [BP-0x7], initializing a flag or counter to zero before entering a loop that traverses a linked list or tree structure (likely the pattern file directory).
00005B74: This is the Borland runtime cleanup stub (`0xf70`) called after a DOS INT 21h function (likely AH=09h print string), used to restore registers after printing a string in the PARMS.DAT parsing or error-reporting routine.
00005C72: Loads the effective address of a stack buffer at [bp-0x17] and pushes it as a far pointer parameter for a call to 0x11C6, which is likely a string concatenation or tokenization routine used during pattern file parsing to extract a component from a line.
00005C83: This pushes SS onto the stack as part of setting up a far pointer parameter for a call to 0x11AD, which is likely a string copy routine, with the destination being a stack-based buffer at [BP-0x17] used for temporary string storage during pattern file parsing.
00005C97: This sets CL=0x0E (14) as a parameter for a string-length or formatting routine at 0x1475, likely used to format a fixed-width field (14 characters) during pattern file display or parsing.
00005DDB: This is part of a data structure initialization routine that zeroes out fields in a memory block (likely a file control block or pattern buffer), with `pop es` restoring the segment register after `les di` loaded a pointer from `[0x380]`.
00005E77: The `push di` at 0x5E77 pushes a pointer (ES:DI) onto the stack as a parameter for the subsequent call to 0x11DC, which appears to be a string formatting or output routine, with AX=0x3030 (ASCII "00") being prepared as a fill character.
00005FC9: This instruction loads a far pointer from `[bp+0x6]` into `ES:DI`, preparing to pass a string parameter (likely a file path or pattern name) to a string comparison or display routine, part of the pattern-loading or menu-handling logic around the "load pattern
00005FE6: This pushes the value `0x1` onto the stack as a parameter for a call to `0x3333`, which is a Borland runtime routine that likely prints a string or character to the screen (possibly the "Load exec" prompt or a menu item).
0000602A: This is setting up to call a string-printing routine (0x4822) with the value 0xE2, which corresponds to the "Error in executive loading... check controller" string, as part of the executive-loading error-handling path after a failed load attempt.
0000614D: This is inline string data for "Printer ON" (the bytes at 0x614D-0x6157 spell "Printer ON"), used by the F6 printer toggle display routine at subroutine `0x28f1`.
00006161: This calls subroutine `0x24e9`, which is a string-printing routine that outputs the text "Printer ON" (or "Printer OFF") to the screen as part of the F6 printer toggle functionality.
00006278: This sets CL=0x3C (60) as a buffer-size parameter for a string-copy or formatting call at 0x2C0F, used when constructing the controller address string (e.g., "773000G") during PARMS.DAT parsing.
00006284: This `call 0x135f` invokes a string-length or comparison function on the buffer at `[bp-0x5e]`, checking if the entered controller address string (e.g., "773000G") has more than 3 characters, validating the UART address format during PARMS.DAT parsing.
000062C5: This pushes AX=0x2E01 onto the stack — the value 0x2E is the ASCII code for period ('.') and 0x01 is likely a length or flag — as part of constructing a filename extension or path separator for a file operation in the pattern import/export routine.
00006359: This pushes `0x19` (decimal 25) as a parameter to a call at `0x370`, which is a Borland runtime routine that sets the cursor position (row 25, column 0x50=80) — likely positioning the cursor for a status line or prompt at the bottom of the screen.
000063F2: This sets `AX=0x1` as a parameter for a call to `0xd8b`, which is a Borland runtime delay or sleep function, used to pause briefly after displaying a menu prompt or error message (likely during the executive loading sequence).
000064A8: This is the entry point of a subroutine that allocates a large stack frame (0x2ce bytes) for local buffers, likely used in the PARMS.DAT parsing or pattern-file path construction, as indicated by the `sub sp,0x2ce` and `lea di,[bp-0x2cc]` immediately following
000064B4: This calls subroutine 0x801, which is a Borland runtime initialization routine that sets up the heap and memory manager, called at the start of a large stack-frame subroutine (0x2CE bytes) for PARMS.DAT parsing or pattern-file path construction.
0000653E: This loads the value 0x20 (space character) and pushes it as an argument, preparing to call subroutine 0x2819 (a character-output or string-display routine), likely to print a space during terminal-mode output formatting.
0000660E: This is calling subroutine 0x32A9 (a cursor-positioning or display routine) with AX=0x00 and AX=0x4E pushed as arguments, setting up to display a character or prompt at a specific screen position during the PARMS.DAT configuration prompts.
00006683: This calls subroutine 0x1003, which is a DOS file-close or file-handle cleanup routine, called between file operations (opening/closing pattern files or PARMS.DAT) during the pattern-loading workflow.
000066BF: This sets AX=0x1 (true) as part of a boolean logic chain checking whether a character is '.' (0x2E), used in filename extension validation during pattern file parsing.
000066ED: This calls subroutine `0x1003`, which is a keyboard input routine that reads a keystroke from the BIOS (INT 16h) — part of the terminal mode where operator keystrokes are captured for transmission to the PDP-11 controller.
000066F4: This zero-extends a byte from `[bp-0x22e]` (a keystroke character) into AX, then compares it against 0x60 ('`'), checking if the key is a lowercase letter or other character below that ASCII value, as part of the terminal-mode keystroke processing before trans
00006743: This calls subroutine `0x23e4`, which is a string-display routine that outputs the "Enter heading" prompt (at string address `0x6749`) to the screen during pattern heading entry.
000068A9: `push ss` pushes the stack segment onto the stack as part of setting up a far pointer argument (SS:DI pointing to `[bp-0x40]`) for the call to 0x11c6, which is a string-copy or string-concatenation routine used in the file-name or path-building logic.
000068C7: The instruction `sub ax,0x7020` is actually part of inlined string data (the bytes "e x i s t   p r e s s   < E S C >   t o   a b o r t") being executed as code due to disassembly misalignment — this is not a meaningful instruction but rather ASCII text embedd
0000694B: This pushes DI (a pointer to [bp-0x21]) onto the stack as a source string parameter for a string-copy call at 0x11C6, copying a short string (likely a file extension or directory name) during pattern file path construction.
000069A4: This loads a character from the local variable at `[bp-0x20]` (a user-input buffer) to check if it's a space character (0x20), as part of parsing or validating operator input in the pattern-file or heading-entry routine.
000069E4: This calls subroutine 0x230b with CX=0x80 (128 bytes), which is a string-copy or buffer-fill routine, likely copying a file path or pattern name into the local buffer at `[bp-0x22c]` during the pattern-file import or listing process.
000069EB: This pushes SS (stack segment) as a far pointer argument to subroutine 0x24fb, which is a string-display or console-output routine, preparing to print the pattern file path or name that was just copied into the buffer.
000069EF: This loads the effective address of `[bp-0x40]` (a local buffer for file path construction) and pushes SS:DI as a far pointer argument to subroutine 0x11AD, which is a string-copy or path-concatenation routine used when building the full path to a pattern file
00006A13: This loads a byte from address `[0x389]`, which is a global flag (likely indicating whether the executive has been loaded or a pattern is active), then toggles it with `xor al,0x1` to check its state before deciding whether to display a warning or proceed with
00006A18: This XORs AL with 0x01, toggling the least significant bit of the flag at `[0x389]`, which is used to check whether a pattern or executive is active, determining whether to display a warning or proceed with the current operation.
00006A3E: This calls subroutine `0x1f7` (a delay or timing routine) with AX=0x32 (50 decimal), used as a pause between printing characters (like periods or dots) during the executive loading progress display.
00006AC0: This pushes AX=0 (a zero parameter) onto the stack before calling subroutine `0x32a9` (which is the INT 10h BIOS video character-printing routine), used to print a period character (0x2E) at a specific screen position during progress indication.
00006B16: This pushes `0x0` as a parameter (along with `0x54` = 'T' on the stack) to a call at `0x32a9`, which is a character-output routine — part of building the string "TRINITY" (the parameters password) on screen during the PARMS.DAT configuration display.
00006B25: This loads AX=0x46 ('F'), which is pushed as a parameter to a character-output routine at 0x1F7, part of building the string "TRINITY" (the parameters password) on screen during the PARMS.DAT configuration display.
00006C18: This calls the string-input routine at 0x30f5 with a far pointer to `[bp-0x22d]` on the stack, reading a character or string from the user (likely a single keystroke or filename component) during the pattern-file import or heading-entry dialog.
00006C73: This pushes the character value from `[bp-0x22d]` onto the stack as an argument to subroutine 0x2819, which is a serial-port send-byte wrapper (INT 14h AH=1), sending a single character to the PDP-11 controller during pattern-file transfer or terminal-mode ope
00006D6E: This calls subroutine `0x11ad` (a string-length or string-comparison routine) with a pointer to a buffer at `[bp-0xcf]`, part of the file-name or path validation logic in the pattern-file or executive-file selection routine.
00006EF7: This is an infinite loop (`jmp 0x6ef2` jumps back to the `call 0xd85` at 0x6ef2) that waits for a serial-port receive condition to succeed (the call at 0xd85 is an INT 14h receive-byte wrapper that returns with ZF set on timeout/error), implementing a blocking
00006F12: This loads the effective address of `[bp-0xcf]` (a local buffer) and pushes SS:DI as a far pointer argument to subroutine 0x11AD, which is a string-copy routine used to store or manipulate a received serial-port message or command string from the PDP-11 contro
00006FEC: This pushes the far pointer to `[bp-0x22c]` (a local buffer) onto the stack as an argument to subroutine 0x11AD, which is a string-copy routine used to duplicate or preserve a file path or pattern name during the file-deletion warning or disk-error handling ro
00007014: This `push ss` passes the stack segment as a parameter for a call to `0x24cc`, which is a string-copy or concatenation routine, building a full file path from a directory buffer and filename during the "Import pattern file" or "save pattern tape" operation.
00007100: This calls subroutine 0x2C0F with CX=0x10 (16 bytes) and DS:DI pointing to string at 0x3AF8, which is a string-comparison or memory-compare routine used to validate the parameters password "TRINITY" against user input during PARMS.DAT configuration.
0000713F: This sets `AX=0x1` to indicate a successful operation (likely enabling printer output or confirming a file save), storing the result into a flag at `[bp-0x27b]` before checking another flag at `[0x387]` to decide whether to call the printer-toggle routine at `
000072E1: This `pop es` instruction restores the extra segment register after a `les di` operation, as part of initializing a file control block or directory entry structure (zeroing fields at offset `+0x5` and `+0x7`) for file operations.
0000731E: This loads `es:di` from `[bp-0x6]` (a far pointer stored on the stack) — it's setting up the destination pointer for copying a string or data structure, part of the file-list or directory-entry manipulation code.
00007393: This pushes a byte parameter (the character from `[bp+0x4]`) onto the stack as a word (zero-extended), preparing to call subroutine 0x2819 (character output) to display a single character, likely during the pattern-file transmission or terminal echo.
000073BF: This `mov dx,es` captures the segment portion of a far pointer stored at `[0x260]` (likely a Borland runtime heap or string descriptor), storing it into a data structure being built on the stack, part of a file-open or memory-allocation routine.
0000748D: This `ret` instruction returns from a subroutine that traverses a linked list of file entries (likely from LIST.DAT), ending the iteration after processing all pattern files in the directory listing.
000074C1: This `xor al,0x1` toggles the least significant bit of AL, implementing a boolean flag flip — part of a loop that toggles a state variable (likely the printer ON/OFF toggle or a pattern format selection) with a timeout counter (`0x7d0` = 2000 iterations).
0000752F: This zero-extends a byte from `[bp-0x3]` (a menu selection or index) into AX, then compares it against the value at `[0x393]` (a maximum count or limit), checking if the selection is within valid range before proceeding with the corresponding action.
000075C4: This calls the string-to-number conversion routine at 0x26e0 with a far pointer to `[bp-0x3]` on the stack, converting an ASCII string (likely a baud rate or parameter value entered by the user) into a numeric value for the PARMS.DAT configuration parser.
00007738: This sets `AX=0x1` as a parameter for a call to `0x3045`, which is the serial-port initialization routine (INT 14h AH=0), configuring the UART with baud rate, parity, and other parameters loaded from PARMS.DAT during the startup sequence.
0000777D: This is a conditional jump (JNZ) that checks if byte [0x386] is non-zero, part of a polling loop in the serial receive routine that waits for a character from the PDP-11 controller, looping back to 0x7773 if no character is ready.
